Generally, the development of software is performed via a series of procedures ranging from the derivation of requirements of engineers to the design of functions, the implementation of code, and the verification of software. During these procedures, a large number of difficulties are present, but tools for obviously arranging requirements, tools for modeling functions, tools for supporting the programming of code, etc. have been developed and have provided lots of help to software developers.
However, in order for engineers to implement software based on derived requirements, a detailed function of meeting the requirements must be designed and the functions thereof must be implemented as code, but there is no tool for directly supporting a method for implementing the detailed function as code. In other words, there is no tool for causing the functionality of software to correspond to code in a one-to-one manner and obviously checking and implementing code in relation to the location of software code where requirements and functional designs are implemented, how they are implemented, and which relationships with other functions exist.
Functions represented in a typical language, drawing or diagram are understood by a human being and must be represented in other forms such as code. That is, such representation must be converted from a normal language into a programming language via a medium such as a human. Due thereto, even if a function is desirably designed, it may not match the implemented code thereof, or the corresponding function may be erroneously implemented, with the result that many errors may be detected in software. Further, although not expressed outwardly, if code is modified in a way different from which the code was intended to be implemented, there is the strong latent possibility that errors will occur.
In the case of software for which a long period of time has elapsed since the implementation thereof, even if defined requirements and design data are present, there may occur a phenomenon in which the structure of the software code thereof cannot be easily understood. That is, due to the difference in representation between the normal language required to represent the functionality of software and the code used to implement software, software code may include therein several unintended elements, depending not only on personal tendency and intention of the person who implements the software code and a scheme for solving the problem, but also on a method for understanding requirements and a method for reinterpreting the design of software. Due to this point, those elements become a great impediment to the universal understanding and interpretation of code, and the readability of software code is deteriorated, thus preventing the efficient development of software.
It is more difficult to read and understand a programming language than a typical language. In a programming language, code must be sequentially configured depending on the flow of control, and must be precisely declared and defined for each representation. That is, unless components in a programming language are sequentially represented according to the sequence, the representation has a different meaning. Unless the forms or meanings of data used in such a programming language and syntax such as command statements are precisely defined, errors may occur. The reason for this is that it is impossible for a computer to determine or understand data in consideration of context, and thus statements in all programming languages must be clearly defined and sequenced to constitute a single meaning. Due thereto, normal source code is configured in the form of text, and a semantic unit of code is represented by a single line, and thus code is configured depending on the sequence of lines.
A programming language does not precisely represent diagrams or drawings that were used to help the understanding of a human being or philosophical or abstract functions when functions are defined. In addition, since the semantic units of code are lines, it is not easy to understand the degree of detailed implementation of software in the case of a large amount of code until the meaning of the code is interpreted by individually and directly inspecting the lines thereof. Of course, it is possible to investigate the approximate meanings of the code using a design document. However, as described above, since a difference in representation is present between the design document and actual code (difference in representation between a normal language and a programming language), a problem arises in that a method in which code constituting actual software is implemented cannot be checked merely by viewing the design document.